home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / emerald / emrldsys.lha / Language / Compiler / buildATs.c < prev    next >
C/C++ Source or Header  |  1990-08-16  |  14KB  |  459 lines
  1. /*
  2.  * @(#)buildATs.c    1.5  1/20/89
  3.  */
  4. #include "assert.h"
  5. #include "error.h"
  6. #include "ident.h"
  7. #include "nodes.h"
  8. #include "builtins.h"
  9. #include "symbols.h"
  10. #include "sequence.h"
  11. #include "MyParser.h"
  12. #include "semantics.h"
  13. #include "evaluate.h"
  14. #include "buildATs.h"
  15. #include "opNames.h"
  16. #include "system.h"
  17. #include "map.h"
  18. #include "flags.h"
  19. #include "environment.h"
  20. #include "trace.h"
  21.  
  22. static int doClearSymbols = FALSE;
  23.  
  24. int compareSigs(a, b)
  25. NodePtr *a, *b;
  26. {
  27.   assert((*a)->tag == P_OPSIG);
  28.   assert((*a)->b.opsig.name->tag == P_OPNAME);
  29.   assert((*b)->tag == P_OPSIG);
  30.   assert((*b)->b.opsig.name->tag == P_OPNAME);
  31.   return((*a)->b.opsig.name->b.opname.id - (*b)->b.opsig.name->b.opname.id);
  32. }
  33.  
  34. static Map copyMap;
  35.  
  36. NodePtr copyTree(), _copyTree();
  37. #define COPYTREE(T) ((int)(T) <= 0x200 ? (T) : _copyTree(T))
  38.  
  39. void copySymbol(new, old)
  40. NodePtr new, old;
  41. { 
  42.   register Symbol s = old->b.symdef.symbol;
  43.   register Symbol newS;
  44.   register NodePtr r;
  45.   NodePtr list;
  46.   register int mapResult;
  47.  
  48.   mapResult = Map_Lookup(copyMap, (int)s);
  49.   if (old->tag == P_SYMDEF) {
  50.     newS = (Symbol) malloc(sizeof(STEntry));
  51.     *newS = *s;
  52.     Map_Insert(copyMap, (int)s, (int)newS);
  53.     if (mapResult == NIL) {
  54.       /* this is the first time we saw the symbol */
  55.     } else {
  56.       /* we need to fix previously seen symrefs */
  57.       assert(mapResult < 0);
  58.       list = (NodePtr) (-mapResult);
  59.       assert(list->tag == T_SEQUENCE);
  60.       Sequence_For(r, list)
  61.     assert(r->tag == P_SYMREF);
  62.     r->b.symref.symbol = newS;
  63.       Sequence_Next
  64.       free((char *) list);
  65.     }
  66.     if (doClearSymbols) {
  67.       newS->value.ATinfo = NULL;
  68.       newS->value.CTinfo = NULL;
  69.       newS->value.value = NULL;
  70.       newS->isManifest = FALSE;
  71.       newS->hasValue = FALSE;
  72.     } else {
  73.       newS->value.ATinfo = COPYTREE(s->value.ATinfo);
  74.       newS->value.CTinfo = COPYTREE(s->value.CTinfo);
  75.       newS->value.value = COPYTREE(s->value.value);
  76.     }
  77.     new->b.symdef.symbol = newS;
  78.   } else {
  79.     assert(old->tag == P_SYMREF);
  80.     if (mapResult != NIL && mapResult > 0) {
  81.       new->b.symref.symbol = (Symbol) mapResult;
  82.     } else {
  83.       if (mapResult == NIL) {
  84.     list = F_NewNode(T_SEQUENCE, 4);
  85.     Map_Insert(copyMap, (int)s, -(int)list);
  86.       } else {
  87.     list = (NodePtr) (-mapResult);
  88.       }
  89.       Sequence_Add(&list, new);
  90.       new->b.symref.symbol = old->b.symref.symbol;
  91.     }
  92.   }
  93. }
  94.  
  95. static Boolean isExported(opname, exports)
  96. register NodePtr opname, exports;
  97. {
  98.   register NodePtr q, exportList;
  99.   if (exports == NN) return(FALSE);
  100.   exportList = exports->b.export.syms;
  101.   assert(opname->tag == P_OPNAME);
  102.   assert(isASequence(exportList));
  103.   Sequence_For(q, exportList)
  104.     assert(q->tag == P_OPNAME);
  105.     if (q->b.opname.id == opname->b.opname.id) return(TRUE);
  106.   Sequence_Next
  107.   return(FALSE);
  108. }
  109.  
  110. NodePtr buildComplicatedSymbol();
  111. extern void sortATOps();
  112.  
  113. NodePtr buildATOfObject(o)
  114. NodePtr o;
  115. {
  116.   register NodePtr at, p, ops, q;
  117.   register Symbol st, newst;
  118.   int stage;
  119.   
  120.   assert(o->tag == P_OBLIT);
  121.   at = Construct(P_ATLIT, 4, o->b.oblit.sfname, NULL, NULL, NULL);
  122.   at->b.atlit.f.immutable = o->b.oblit.f.immutable;
  123.  
  124.   TRACE4(copy, 1, "BuildATOf %s %s 0x%08x -> 0x%08x", 
  125.     tagNames[(int)o->tag],
  126.     o->b.oblit.name == NN ? "unknown" : 
  127.       ST_SymbolName(o->b.oblit.name->b.symdef.symbol),
  128.     o,
  129.     at);
  130.  
  131.   st = ST_Fetch(o->b.oblit.name->b.symdef.symbol);
  132.   at->b.atlit.name = 
  133.     buildComplicatedSymbol(P_SYMDEF, ST_SymbolName(st), 0, "_IAT");
  134.   at->b.atlit.name->b.symdef.symbol = 
  135.     ST_Create(NN, at->b.atlit.name->b.symdef.ident);
  136.   newst = ST_Fetch(at->b.atlit.name->b.symdef.symbol);
  137.   newst->itsName = Ident_Name(newst->itsIdent);
  138.   at->b.atlit.name->b.symdef.ident = newst->itsIdent;
  139.  
  140.   newst->value.value = at;
  141.   newst->value.ATinfo = refToBuiltin(B_INSTAT, SIGNATUREINDEX);
  142.   newst->value.CTinfo = refToBuiltin(B_INSTCT, SIGNATUREINDEX);
  143.   newst->isManifest = TRUE;
  144.   newst->hasValue = TRUE;
  145.  
  146.   at->b.atlit.ops = NULL;
  147.   for (stage = 0; stage < 2; stage++) {
  148.     if (stage == 0) {
  149.       ops = o->b.oblit.monitor;
  150.       if (ops != NULL) {
  151.     assert(ops->tag == P_MONITOR);
  152.     ops = ops->b.monitor.ops;
  153.       }
  154.     } else if (stage == 1) {
  155.       ops = o->b.oblit.ops;
  156.     } 
  157.     Sequence_For(p, ops)
  158.       assert(p->tag == P_OPDEF);
  159.       q = p->b.opdef.sig;
  160.       assert(q->tag == P_OPSIG);
  161. #ifdef COPYSIGS
  162.       Sequence_Add(&at->b.atlit.ops, copyTree(q, TRUE));
  163. #else
  164.       Sequence_Add(&at->b.atlit.ops, q);
  165. #endif
  166.       p->b.opdef.isExported = isExported(q->b.opsig.name, o->b.oblit.export);
  167.     Sequence_Next
  168.   }
  169.   sortATOps(at);
  170. #ifdef COPYSIGS
  171.   newAssignTypes(at, 1);
  172. #else
  173.   at->b.atlit.f.typesAreAssigned = TRUE;
  174. #endif
  175.  
  176.   at->b.atlit.f.isVector = o->b.oblit.f.isVector;
  177.   if (at->b.atlit.f.isVector) {
  178.     at->b.atlit.f.cannotBeConformedTo = TRUE;
  179.     at->b.atlit.codeOID = o->b.oblit.codeOID;
  180.   }
  181.   if (o->b.oblit.f.dependsOnTypeVariable) {
  182.     assert(o->b.oblit.f.writeSeparately == FALSE);
  183.     at->b.atlit.f.isManifest = FALSE;
  184.     at->b.atlit.f.writeSeparately = FALSE;
  185.     at->b.atlit.f.dependsOnTypeVariable = TRUE;
  186.     at->b.atlit.id = AllocateOID();
  187.     OTInsert(at, at->b.atlit.id);
  188.   } else if (o->b.oblit.f.typeDependsOnTypeVariable) {
  189.     at->b.atlit.f.isManifest = FALSE;
  190.     at->b.atlit.f.writeSeparately = FALSE;
  191.     at->b.atlit.f.dependsOnTypeVariable = TRUE;
  192.     at->b.atlit.id = AllocateOID();
  193.     OTInsert(at, at->b.atlit.id);
  194.   } else {
  195.     defineGlobal(at, 0);
  196.   }
  197.   return(at);
  198. }
  199.  
  200. NodePtr getExportedATOfObject(o, fAT)
  201. NodePtr o, fAT;
  202. {
  203.   NodePtr exports, export, ops, p, q, at;
  204.   OID opID;
  205.   Boolean *isDefined;
  206.   int numSigs;
  207.   Symbol st, newst;
  208.   register int i, j;
  209.  
  210.   assert(o->tag == P_OBLIT);
  211.   assert(fAT->tag == P_ATLIT);
  212.   exports = o->b.oblit.export;
  213.   if (exports != NULL) {
  214.     assert(exports->tag == P_EXPORT);
  215.     exports = exports->b.export.syms;
  216.   }
  217.   numSigs = Sequence_Length(exports);
  218.   at = Construct(P_ATLIT, 4, o->b.oblit.sfname, NULL, NULL, NULL);
  219.   at->b.atlit.f.immutable = o->b.oblit.f.immutable;
  220.  
  221.   TRACE4(copy, 1, "GetExportedATOf %s %s 0x%08x -> 0x%08x", 
  222.     tagNames[(int)o->tag],
  223.     o->b.oblit.name == NN ? "unknown" : 
  224.       ST_SymbolName(o->b.oblit.name->b.symdef.symbol),
  225.     o,
  226.     at);
  227.  
  228.   st = ST_Fetch(o->b.oblit.name->b.symdef.symbol);
  229.   at->b.atlit.name = 
  230.     buildComplicatedSymbol(P_SYMDEF, ST_SymbolName(st), 0, "_XAT");
  231.   at->b.atlit.name->b.symdef.symbol = 
  232.     ST_Create(NN, at->b.atlit.name->b.symdef.ident);
  233.   newst = ST_Fetch(at->b.atlit.name->b.symdef.symbol);
  234.   at->b.atlit.name->b.symdef.ident = newst->itsIdent;
  235.   newst->value.value = at;
  236.   newst->value.ATinfo = refToBuiltin(B_INSTAT, SIGNATUREINDEX);
  237.   newst->value.CTinfo = refToBuiltin(B_INSTCT, SIGNATUREINDEX);
  238.   newst->hasValue = TRUE;
  239.   newst->isManifest = TRUE;
  240.  
  241.   at->b.atlit.ops = NULL;
  242.   isDefined = (Boolean *) calloc((unsigned)numSigs, sizeof(Boolean));
  243.   ops = fAT->b.atlit.ops;
  244.   Sequence_For(p, ops)
  245.     assert(p->tag == P_OPSIG);
  246.     q = p->b.opsig.name;
  247.     assert(q->tag == P_OPNAME);
  248.     opID = q->b.opname.id;
  249.     for (j = 0; j < numSigs; j++) {
  250.       export = exports->b.children[j];
  251.       assert(export->tag == P_OPNAME);
  252.       if (export->b.opname.id == opID) {
  253.     NodePtr theop;
  254.     isDefined[j] = TRUE;
  255.     theop = findObjectOperation(o, export);
  256.     if (theop->b.opdef.isPrivate) {
  257.       ErrorMessage(theop, "Private operations may not be exported");
  258.     }
  259. #ifdef COPYSIGS
  260.     Sequence_Add(&at->b.atlit.ops, copyTree(p, TRUE));
  261. #else
  262.     Sequence_Add(&at->b.atlit.ops, p);
  263. #endif
  264.     break;
  265.       }
  266.     }
  267.   Sequence_Next
  268.   if (Sequence_Length(at->b.atlit.ops) != numSigs) {
  269.     for (i = 0; i < numSigs; i++) {
  270.       if (!isDefined[i]) {
  271.     BeginErrorMessage(o);
  272.     (void) sprintf(error_buffer, "Exported operation %s is not defined", 
  273.       ON_Name(exports->b.children[i]->b.opname.id));
  274.     ErrorWrite(error_buffer);
  275.     EndErrorMessage();
  276.       }
  277.     }
  278.   }
  279.   if (Sequence_Length(at->b.atlit.ops) > 1) {
  280.     TRACE1(atctsort, 2, "QSorting at %s", ATName(at));
  281.     qsort((char *)&(at->b.atlit.ops->b.children[0]),
  282.       Sequence_Length(at->b.atlit.ops),
  283.       sizeof(NodePtr),
  284.       compareSigs);
  285.     for (i = 0; i < Sequence_Length(at->b.atlit.ops); i++) {
  286.       TRACE2(atctsort, 4, "Operation %s has number %d",
  287.     SigName(at->b.atlit.ops->b.children[i]), i);
  288.     }
  289.   }
  290.  
  291.   defineGlobal(at, 0);
  292.   at->b.atlit.f.isVector = o->b.oblit.f.isVector;
  293.   if (at->b.atlit.f.isVector) {
  294.     at->b.atlit.f.cannotBeConformedTo = TRUE;
  295.     at->b.atlit.codeOID = o->b.oblit.codeOID;
  296.   }
  297.   at->b.atlit.f.writeSeparately = fAT->b.atlit.f.writeSeparately;
  298.   at->b.atlit.f.isManifest = fAT->b.atlit.f.isManifest;
  299.   at->b.atlit.f.dependsOnTypeVariable = fAT->b.atlit.f.dependsOnTypeVariable;
  300.   return(at);
  301. }
  302.  
  303. void initializebuildATs()
  304. {
  305. }
  306.  
  307. extern Boolean internalConforms();
  308.  
  309. Boolean isAnAT(p)
  310. register NodePtr p;
  311. {
  312.   register Symbol st;
  313.   if ((int) p <= 0x200) {
  314.     return(FALSE);
  315.   } else if (p->tag == P_ATLIT) {
  316.     return (TRUE);
  317.   } else if (p->tag == P_BUILTINLIT) {
  318.     return(p->b.builtinlit.whichType != KARRAY &&
  319.        p->b.builtinlit.whichType != KVECTOR);
  320.   } else if (p->tag == P_SYMREF) {
  321.     st = ST_Fetch(p->b.symref.symbol);
  322.     return(st->isManifest && isAnAT(st->value.value));
  323.   } else if (p->tag == P_OBLIT) {
  324.     return(p->b.oblit.instat != NULL);
  325.   } else if (p->tag == P_GLOBALREF) {
  326.     resolveGlobal(p, (ValuePtr)NULL);
  327.     return(isAnAT(p->b.globalref.value));
  328.   } else {
  329.     return(FALSE);
  330.   }
  331. }
  332.  
  333. /*
  334.  * We need to copy all nodes making this object.
  335.  */
  336.  
  337. NodePtr _copyTree(p)
  338. register NodePtr p;
  339. {
  340.   register NodePtr newNode;
  341.   register int i, nRealChildren;
  342.   if ((int) p <= 0x200) {
  343.     newNode = p;
  344.   } else if ((newNode = (NodePtr) Map_Lookup(copyMap, (int)p)) != (NodePtr) NIL) {
  345.     /* do nothing, newNode is the right thing to return */
  346.   } else if ((p->tag == P_ATLIT || p->tag == P_OBLIT) && p->b.atlit.f.writeSeparately) {
  347.     assert(p->b.atlit.id != 0);
  348.     newNode = Construct(P_GLOBALREF, 0);
  349.     newNode->b.globalref.id = p->b.atlit.id;
  350.     newNode->b.globalref.value = p;
  351.   } else {
  352.     nRealChildren = p->nChildren - p->firstChild;
  353.     newNode = F_NewNode(p->tag, nRealChildren);
  354.     newNode->nChildren += nRealChildren;
  355.     newNode->lineNumber = p->lineNumber;
  356.     Map_Insert(copyMap, (int)p, (int)newNode);
  357.     for (i = 0; i < newNode->firstChild; i++)
  358.       newNode->b.children[i] = p->b.children[i];
  359.  
  360.     switch (p->tag) {
  361.       case P_SYMDEF:
  362.       case P_SYMREF:
  363.     copySymbol(newNode, p);
  364.     break;
  365.       case P_INVOC:
  366.     if (doClearSymbols) newNode->b.invoc.resultTypeOID = 0;
  367.     for (i = newNode->firstChild; i < newNode->nChildren; i++)
  368.       newNode->b.children[i] = COPYTREE(p->b.children[i]);
  369.     break;
  370.       case P_VECTORLIT:
  371.     if (doClearSymbols) newNode->b.vectorlit.vectorType = NN;
  372.     for (i = newNode->firstChild; i < newNode->nChildren; i++)
  373.       newNode->b.children[i] = COPYTREE(p->b.children[i]);
  374.     break;
  375.       case P_OBLIT:
  376.       case P_ATLIT:
  377.     TRACE4(copy, 1, "Copying %s %s 0x%08x -> 0x%08x", 
  378.       tagNames[(int)p->tag],
  379.       p->b.oblit.name == NN ? "unknown" : 
  380.         ST_SymbolName(p->b.oblit.name->b.symdef.symbol),
  381.       p,
  382.       newNode);
  383.     if (doClearSymbols) {
  384.       newNode->b.oblit.setq = COPYTREE(p->b.oblit.setq);
  385.       newNode->b.oblit.name = COPYTREE(p->b.oblit.name);
  386.       newNode->b.oblit.name->b.symdef.symbol->isSelf = TRUE;
  387.       newNode->b.oblit.name->b.symdef.symbol->value.value = newNode;
  388.       newNode->b.oblit.id = 0;
  389.       newNode->b.oblit.codeOID = 0;
  390.       newNode->b.oblit.f.isManifest = FALSE;
  391.       newNode->b.oblit.f.writeSeparately = FALSE;
  392.       newNode->b.oblit.f.isTypeVariable = FALSE;
  393.       newNode->b.oblit.f.inExecutableConstruct = FALSE;
  394.       newNode->b.oblit.f.dependsOnTypeVariable = FALSE;
  395.       newNode->b.oblit.f.typesAreAssigned = FALSE;
  396.       newNode->b.oblit.f.typesHaveBeenChecked = FALSE;
  397.       if (p->tag == P_ATLIT) {
  398.         newNode->b.atlit.ops = COPYTREE(p->b.atlit.ops);
  399.       } else {
  400.         newNode->b.oblit.myat = NULL;
  401.         newNode->b.oblit.instat = NULL;
  402.         newNode->b.oblit.export = COPYTREE(p->b.oblit.export);      
  403.         newNode->b.oblit.decls = COPYTREE(p->b.oblit.decls);      
  404.         newNode->b.oblit.monitor = COPYTREE(p->b.oblit.monitor);      
  405.         newNode->b.oblit.ops = COPYTREE(p->b.oblit.ops);      
  406.         newNode->b.oblit.process = COPYTREE(p->b.oblit.process);      
  407.       }
  408.     } else {
  409.       assert(!p->b.atlit.f.writeSeparately);
  410.       if (p->b.atlit.id != 0) {
  411.         newNode->b.atlit.id = AllocateOID();
  412.         OTInsert(newNode, newNode->b.atlit.id);
  413.       }
  414.       for (i = newNode->firstChild; i < newNode->nChildren; i++)
  415.         newNode->b.children[i] = COPYTREE(p->b.children[i]);
  416.       if (newNode->tag == P_OBLIT && newNode->b.oblit.codeOID != 0) {
  417.         newNode->b.oblit.codeOID = AllocateOID();
  418.         OTInsert(newNode, newNode->b.oblit.codeOID);
  419.       }
  420.     }
  421.     break;
  422.       case P_OPSIG:
  423.     newNode->b.opsig.name = p->b.opsig.name;
  424.     newNode->b.opsig.params = COPYTREE(p->b.opsig.params);
  425.     newNode->b.opsig.results = COPYTREE(p->b.opsig.results);
  426.     if (doClearSymbols) {
  427.       newNode->b.opsig.where = p->b.opsig.where;
  428.     } else {
  429.       newNode->b.opsig.where = COPYTREE(p->b.opsig.where);
  430.     }
  431.     break;
  432.       case P_PARAM:
  433.     newNode->b.param.sym = COPYTREE(p->b.param.sym);
  434.     newNode->b.param.type = p->b.param.type;
  435.     newNode->b.param.constraint = p->b.param.constraint;
  436.     break;
  437.       default:
  438.     for (i = newNode->firstChild; i < newNode->nChildren; i++)
  439.       newNode->b.children[i] = COPYTREE(p->b.children[i]);
  440.     break;
  441.     }
  442.   }
  443.   return(newNode);
  444. }
  445.  
  446. NodePtr copyTree(p, clearSymbols)
  447. NodePtr p;
  448. Boolean clearSymbols;
  449. {
  450.   NodePtr result;
  451.   TRACE3(copy, 1, "Copying %s 0x%08x, dCC = %s",
  452.     tagNames[(int)p->tag], p, clearSymbols ? "true" : "false");
  453.   doClearSymbols = clearSymbols;
  454.   copyMap = Map_Create();
  455.   result = COPYTREE(p);
  456.   Map_Destroy(copyMap);
  457.   return(result);
  458. }
  459.